home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / ZSI / schema.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  9.8 KB  |  318 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from ZSI import _copyright, _seqtypes, _find_type, _get_element_nsuri_name, EvaluateException
  5. from ZSI.wstools.Namespaces import SCHEMA, SOAP
  6. from ZSI.wstools.Utility import SplitQName
  7.  
  8. def _get_type_definition(namespaceURI, name, **kw):
  9.     return SchemaInstanceType.getTypeDefinition(namespaceURI, name, **kw)
  10.  
  11.  
  12. def _get_global_element_declaration(namespaceURI, name, **kw):
  13.     return SchemaInstanceType.getElementDeclaration(namespaceURI, name, **kw)
  14.  
  15.  
  16. def _get_substitute_element(head, elt, ps):
  17.     if not isinstance(head, ElementDeclaration):
  18.         return None
  19.     
  20.     return ElementDeclaration.getSubstitutionElement(head, elt, ps)
  21.  
  22.  
  23. def _has_type_definition(namespaceURI, name):
  24.     return SchemaInstanceType.getTypeDefinition(namespaceURI, name) is not None
  25.  
  26.  
  27. def _is_substitute_element(head, sub):
  28.     if not isinstance(head, ElementDeclaration) or not isinstance(sub, ElementDeclaration):
  29.         return False
  30.     
  31.     
  32.     try:
  33.         group = sub.substitutionGroup
  34.     except (AttributeError, TypeError):
  35.         return False
  36.  
  37.     ged = GED(*group)
  38.     if head.nspname == ged.nspname:
  39.         pass
  40.     print head.pname == ged.pname
  41.     if not head is ged:
  42.         if head.nspname == ged.nspname:
  43.             pass
  44.         if not (head.pname == ged.pname):
  45.             return False
  46.         
  47.     return True
  48.  
  49. GED = _get_global_element_declaration
  50. GTD = _get_type_definition
  51.  
  52. def WrapImmutable(pyobj, what):
  53.     return _GetPyobjWrapper.WrapImmutable(pyobj, what)
  54.  
  55.  
  56. def RegisterBuiltin(arg):
  57.     _GetPyobjWrapper.RegisterBuiltin(arg)
  58.     _GetPyobjWrapper.RegisterAnyElement()
  59.  
  60.  
  61. def RegisterAnyElement():
  62.     return _GetPyobjWrapper.RegisterAnyElement()
  63.  
  64.  
  65. class SchemaInstanceType(type):
  66.     types = { }
  67.     elements = { }
  68.     element_typecode_cache = { }
  69.     
  70.     def __new__(cls, classname, bases, classdict):
  71.         if classname in ('ElementDeclaration', 'TypeDefinition', 'LocalElementDeclaration'):
  72.             return type.__new__(cls, classname, bases, classdict)
  73.         
  74.         if ElementDeclaration in bases:
  75.             if classdict.has_key('schema') is False or classdict.has_key('literal') is False:
  76.                 raise AttributeError, 'ElementDeclaration must define schema and literal attributes'
  77.             
  78.             key = (classdict['schema'], classdict['literal'])
  79.             if SchemaInstanceType.elements.has_key(key):
  80.                 return SchemaInstanceType.elements[key]
  81.             
  82.             ged = SchemaInstanceType.elements[key] = type.__new__(cls, classname, bases, classdict)
  83.             return ged
  84.         
  85.         if TypeDefinition in bases:
  86.             if classdict.has_key('type') is None:
  87.                 raise AttributeError, 'TypeDefinition must define type attribute'
  88.             
  89.             key = classdict['type']
  90.             if SchemaInstanceType.types.has_key(key) is False:
  91.                 SchemaInstanceType.types[key] = type.__new__(cls, classname, bases, classdict)
  92.             
  93.             return SchemaInstanceType.types[key]
  94.         
  95.         if LocalElementDeclaration in bases:
  96.             return type.__new__(cls, classname, bases, classdict)
  97.         
  98.         raise TypeError, 'SchemaInstanceType must be an ElementDeclaration or TypeDefinition '
  99.  
  100.     
  101.     def getTypeDefinition(cls, namespaceURI, name, lazy = False):
  102.         klass = cls.types.get((namespaceURI, name), None)
  103.         if lazy and klass is not None:
  104.             return _Mirage(klass)
  105.         
  106.         return klass
  107.  
  108.     getTypeDefinition = classmethod(getTypeDefinition)
  109.     
  110.     def getElementDeclaration(cls, namespaceURI, name, isref = False, lazy = False):
  111.         key = (namespaceURI, name)
  112.         if isref:
  113.             klass = cls.elements.get(key, None)
  114.             if klass is not None and lazy is True:
  115.                 return _Mirage(klass)
  116.             
  117.             return klass
  118.         
  119.         typecode = cls.element_typecode_cache.get(key, None)
  120.         if typecode is None:
  121.             tcls = cls.elements.get(key, None)
  122.             if tcls is not None:
  123.                 typecode = cls.element_typecode_cache[key] = tcls()
  124.                 typecode.typed = False
  125.             
  126.         
  127.         return typecode
  128.  
  129.     getElementDeclaration = classmethod(getElementDeclaration)
  130.  
  131.  
  132. class ElementDeclaration:
  133.     __metaclass__ = SchemaInstanceType
  134.     
  135.     def checkSubstitute(self, typecode):
  136.         if not isinstance(typecode, ElementDeclaration):
  137.             return False
  138.         
  139.         
  140.         try:
  141.             (nsuri, ncname) = typecode.substitutionGroup
  142.         except (AttributeError, TypeError):
  143.             return False
  144.  
  145.         if (nsuri, ncname) != (self.schema, self.literal):
  146.             if not nsuri and not (self.schema) and ncname == self.literal:
  147.                 return True
  148.             
  149.             return False
  150.         
  151.         sub = GED(self.schema, self.literal)
  152.         if sub is None or sub is not typecode:
  153.             return False
  154.         
  155.         return True
  156.  
  157.     
  158.     def getSubstitutionElement(self, elt, ps):
  159.         (nsuri, ncname) = _get_element_nsuri_name(elt)
  160.         typecode = GED(nsuri, ncname)
  161.         if typecode is None:
  162.             return None
  163.         
  164.         
  165.         try:
  166.             (nsuri, ncname) = typecode.substitutionGroup
  167.         except (AttributeError, TypeError):
  168.             return None
  169.  
  170.         if ncname == self.pname:
  171.             if (nsuri == self.nspname or not nsuri) and not (self.nspname):
  172.                 return typecode
  173.             
  174.  
  175.  
  176.  
  177. class LocalElementDeclaration:
  178.     __metaclass__ = SchemaInstanceType
  179.  
  180.  
  181. class TypeDefinition:
  182.     __metaclass__ = SchemaInstanceType
  183.     
  184.     def getSubstituteType(self, elt, ps):
  185.         pyclass = SchemaInstanceType.getTypeDefinition(*self.type)
  186.         if pyclass is None:
  187.             raise EvaluateException('No Type registed for xsi:type=(%s, %s)' % (self.type[0], self.type[1]), ps.Backtrace(elt))
  188.         
  189.         typeName = _find_type(elt)
  190.         (prefix, typeName) = SplitQName(typeName)
  191.         uri = ps.GetElementNSdict(elt).get(prefix)
  192.         if uri is None:
  193.             uri = self.nspname
  194.         
  195.         subclass = SchemaInstanceType.getTypeDefinition(uri, typeName)
  196.         if subclass is None:
  197.             raise EvaluateException('No registered xsi:type=(%s, %s), substitute for xsi:type=(%s, %s)' % (uri, typeName, self.type[0], self.type[1]), ps.Backtrace(elt))
  198.         
  199.         if not issubclass(subclass, pyclass) and subclass(None) and not issubclass(subclass, pyclass):
  200.             raise TypeError('Substitute Type (%s, %s) is not derived from %s' % (self.type[0], self.type[1], pyclass), ps.Backtrace(elt))
  201.         
  202.         return subclass((self.nspname, self.pname))
  203.  
  204.  
  205.  
  206. class _Mirage:
  207.     
  208.     def __init__(self, klass):
  209.         self.klass = klass
  210.         self._Mirage__reveal = False
  211.         self._Mirage__cache = None
  212.         if issubclass(klass, ElementDeclaration):
  213.             self.__call__ = self._hide_element
  214.         
  215.  
  216.     
  217.     def __str__(self):
  218.         msg = '<Mirage id=%s, Local Element %s>'
  219.         if issubclass(self.klass, ElementDeclaration):
  220.             msg = '<Mirage id=%s, GED %s>'
  221.         
  222.         return msg % (id(self), self.klass)
  223.  
  224.     
  225.     def _hide_type(self, pname, aname, minOccurs = 0, maxOccurs = 1, nillable = False, **kw):
  226.         self.__call__ = self._reveal_type
  227.         self._Mirage__reveal = True
  228.         self._Mirage__kw = kw
  229.         self.minOccurs = minOccurs
  230.         self.maxOccurs = maxOccurs
  231.         self.nillable = nillable
  232.         self.nspname = None
  233.         self.pname = pname
  234.         self.aname = aname
  235.         if type(self.pname) in (tuple, list):
  236.             (self.nspname, self.pname) = pname
  237.         
  238.         return self
  239.  
  240.     
  241.     def _hide_element(self, minOccurs = 0, maxOccurs = 1, nillable = False, **kw):
  242.         self.__call__ = self._reveal_element
  243.         self._Mirage__reveal = True
  244.         self._Mirage__kw = kw
  245.         self.nspname = self.klass.schema
  246.         self.pname = self.klass.literal
  247.         self.minOccurs = minOccurs
  248.         self.maxOccurs = maxOccurs
  249.         self.nillable = nillable
  250.         return self
  251.  
  252.     
  253.     def _reveal_type(self):
  254.         if self._Mirage__cache is None:
  255.             self._Mirage__cache = self.klass(pname = self.pname, aname = self.aname, minOccurs = self.minOccurs, maxOccurs = self.maxOccurs, nillable = self.nillable, **self._Mirage__kw)
  256.         
  257.         return self._Mirage__cache
  258.  
  259.     
  260.     def _reveal_element(self):
  261.         if self._Mirage__cache is None:
  262.             self._Mirage__cache = self.klass(minOccurs = self.minOccurs, maxOccurs = self.maxOccurs, nillable = self.nillable, **self._Mirage__kw)
  263.         
  264.         return self._Mirage__cache
  265.  
  266.     __call__ = _hide_type
  267.  
  268.  
  269. class _GetPyobjWrapper:
  270.     types_dict = dict()
  271.     
  272.     def RegisterBuiltin(cls, arg):
  273.         if arg in cls.types_dict:
  274.             raise RuntimeError, '%s already registered' % arg
  275.         
  276.         
  277.         class _Wrapper('_Wrapper', (arg,)):
  278.             'Wrapper for builtin %s\n%s' % (arg, cls.__doc__)
  279.  
  280.         _Wrapper.__name__ = '_%sWrapper' % arg.__name__
  281.         cls.types_dict[arg] = _Wrapper
  282.  
  283.     RegisterBuiltin = classmethod(RegisterBuiltin)
  284.     
  285.     def RegisterAnyElement(cls):
  286.         for k, v in cls.types_dict.items():
  287.             what = Any.serialmap.get(k)
  288.             if what is None:
  289.                 continue
  290.             
  291.             if v in what.__class__.seriallist:
  292.                 continue
  293.             
  294.             what.__class__.seriallist.append(v)
  295.             RegisterType(what.__class__, clobber = 1, **what.__dict__)
  296.         
  297.  
  298.     RegisterAnyElement = classmethod(RegisterAnyElement)
  299.     
  300.     def WrapImmutable(cls, pyobj, what):
  301.         d = cls.types_dict
  302.         if type(pyobj) is bool:
  303.             pyclass = d[int]
  304.         elif d.has_key(type(pyobj)) is True:
  305.             pyclass = d[type(pyobj)]
  306.         else:
  307.             raise TypeError, 'Expecting a built-in type in %s (got %s).' % (d.keys(), type(pyobj))
  308.         newobj = pyclass(pyobj)
  309.         newobj.typecode = what
  310.         return newobj
  311.  
  312.     WrapImmutable = classmethod(WrapImmutable)
  313.  
  314. from TC import Any, RegisterType
  315. if __name__ == '__main__':
  316.     print _copyright
  317.  
  318.